{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c7434524",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    1\n",
      "b    2\n",
      "c    3\n",
      "d    4\n",
      "e    5\n",
      "dtype: int64\n",
      "0    10\n",
      "1    11\n",
      "2    12\n",
      "3    13\n",
      "4    14\n",
      "dtype: int64\n",
      "0    10\n",
      "1    11\n",
      "4    14\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from pandas import Series,DataFrame\n",
    "import numpy as np\n",
    "\n",
    "sel =Series(data=[1,2,3,4,5],index=['a','b','c','d','e'])\n",
    "print(sel)\n",
    "# print(sel.values)\n",
    "# print(sel.index)\n",
    "# 获取索引和值对 以列表的形式展开\n",
    "# print(list(sel.iteritems()))\n",
    "# print(list(sel.iteritems()))\n",
    "#将字典转换成Series\n",
    "dict={\"red\":100,\"black\":400,\"green\":300,\"pink\":900}\n",
    "# se2=Series(dict)\n",
    "# print(se2)\n",
    "# print(dict)\n",
    "\n",
    "# Series对象同时支持位置和标签两种方式获取数据\n",
    "# print('索引下标',sel['c'])\n",
    "# print('位置下标',sel[2])\n",
    "#获取不连续的数据\n",
    "# print('索引下表',sel[['d','e']])\n",
    "# print('位置下表',sel[[3,4]])\n",
    "\n",
    "# print('位置切片',sel[1:3])# 左包含右不包含\n",
    "# print('索引切片',sel['b':'d'])# 左右都包含\n",
    "# Drop丢弃指定轴上的项\n",
    "se13=pd.Series(range(10,15))\n",
    "# print(se13)\n",
    "# print(se13.drop([2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "8e45391c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a    1\n",
      "b    6\n",
      "c    3\n",
      "d    5\n",
      "dtype: int64\n",
      "b    6\n",
      "d    5\n",
      "dtype: int64\n",
      "a     2\n",
      "b    12\n",
      "c     6\n",
      "d    10\n",
      "dtype: int64\n",
      "a     1\n",
      "b    36\n",
      "c     9\n",
      "d    25\n",
      "dtype: int64\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "对 Series 的算术运算都是基于 index 进行的。\n",
    "我们可以用加减乘除（+ - * /）这样的运算符对两个 Series 进行运算，\n",
    "Pandas 将会根据索引 index，对响应的数据进行计算，结果将会以浮点数的形式存储，以避免丢失精度。\n",
    "如果 Pandas 在两个 Series 里找不到相同的 index，对应的位置就返回一个空值 NaN\n",
    "'''\n",
    "# series1 = pd.Series([1,2,3,4],['London','HongKong','Humbai','lagos'])\n",
    "# series2 = pd.Series([1,3,6,4],['London','Accra','lagos','Delhi'])\n",
    "# print(series1)\n",
    "# print(series2)\n",
    "# print(series1-series2)\n",
    "# print(series1+series2)\n",
    "\n",
    "# 同样也支持numpy的数组运算\n",
    "sel = Series(data = [1,6,3,5], index = list('abcd'))\n",
    "print(sel)\n",
    "print(sel[sel>3]) # 布尔数组过滤\n",
    "print(sel*2) # 标量乘法\n",
    "print(np.square(sel)) # 可以直接加入到numpy的数学函数x**2  平方计算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "af94ca34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Name Age country\n",
      "a   zs  10      中国\n",
      "b   ls  20      韩国\n",
      "c   we  30      日本\n",
      "d  NaN  40     NaN\n",
      "{'Name': {'a': 'zs', 'b': 'ls', 'c': 'we', 'd': nan}, 'Age': {'a': '10', 'b': '20', 'c': '30', 'd': '40'}, 'country': {'a': '中国', 'b': '韩国', 'c': '日本', 'd': nan}}\n"
     ]
    }
   ],
   "source": [
    "df1 = DataFrame(np.random.randint(0,10,(4,4)),index=[1,2,3,4],columns=['a','b','c','d'])\n",
    "# print(df1)\n",
    "# 使用字典创建(行索引由index决定，列索引由字典的键决定)\n",
    "dict={\n",
    "'Province': ['Guangdong', 'Beijing', 'Qinghai', 'Fujian'],\n",
    "'pop': [1.3, 2.5, 1.1, 0.7],\n",
    "'year': [2018, 2018, 2018, 2018]}\n",
    "df2=pd.DataFrame(dict,index=[1,2,3,4])\n",
    "# print(df2)\n",
    "# 使用from_dict\n",
    "dict3={\"a\":[1,2,3],\"b\":[4,5,6]}\n",
    "df3=pd.DataFrame.from_dict(dict3)\n",
    "# print(df3)\n",
    "\n",
    "#索引相同的情况下，相同索引的值会相对应，缺少的值会添加NaN\n",
    "data = {\n",
    "'Name':pd.Series(['zs','ls','we'],index=['a','b','c']),\n",
    "'Age':pd.Series(['10','20','30','40'],index=['a','b','c','d']),\n",
    "'country':pd.Series(['中国','日本','韩国'],index=['a','c','b'])\n",
    "}\n",
    "df = pd.DataFrame(data)\n",
    "print(df)\n",
    "# to_dict()方法将DataFrame对象转换为字典\n",
    "dict=df.to_dict()\n",
    "print(dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "094c2b75",
   "metadata": {},
   "source": [
    "# DataFrame对象常用属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "f1a79de7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       name age national\n",
      "0     James  18       us\n",
      "1     Curry  20    China\n",
      "2  Iversion  19       us\n",
      "       name age national\n",
      "0     James  18       us\n",
      "2  Iversion  19       us\n",
      "1     Curry  20    China\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from pandas import Series,DataFrame\n",
    "import numpy as np\n",
    "\n",
    "# dataframe常用属性\n",
    "df_dict = {\n",
    "'name':['James','Curry','Iversion'],\n",
    "'age':['18','20','19'],\n",
    "'national':['us','China','us']\n",
    "}\n",
    "df = pd.DataFrame(data=df_dict,index=['0','1','2'])\n",
    "print(df)\n",
    "# 获取行数和列数\n",
    "# print(df.shape)\n",
    "# # # 获取行索引\n",
    "# print(df.index.tolist())\n",
    "# 获取列索引\n",
    "# print(df.columns.to_list())\n",
    "# 获取数据的类型\n",
    "# print(df.dtypes)\n",
    "# # 获取数据的维度\n",
    "# print(df.ndim)\n",
    "# # values属性也会以二维ndarray的形式返回DataFrame的数据\n",
    "# print(df.values)\n",
    "# # 展示df的概览\n",
    "# print(df.info())\n",
    "# # 显示头几行,默认显示5行\n",
    "# print(df.head(2))\n",
    "# # 显示后几行\n",
    "# print(df.tail(1))\n",
    "# 获取DataFrame的列\n",
    "# print(type(df['name']))\n",
    "# print(df[['name','age']])\n",
    "# print(type(df[['name','age']]))\n",
    "# 获取一行\n",
    "# print(df[0:1])\n",
    "#获取多行\n",
    "# print(df[1:3])\n",
    "# 取多行里面的某一列（不能进行多行多列的选择）\n",
    "# print(df[1:3][['name','age']])\n",
    "# 注意： df[]只能进行行选择，或列选择，不能同时多行多列选择。\n",
    "# 获取某一行某一列的数据\n",
    "# print(df.loc['0',['name','national']])\n",
    "# print(df.loc[['0','2'],['name','age']])\n",
    "# df=df.sort_values(by='age',ascending='True')\n",
    "# print(df)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ab9ad92",
   "metadata": {},
   "source": [
    "# dataframe修改index、columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "959b6ef3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    a  b  c\n",
      "bj  0  1  2\n",
      "sh  3  4  5\n",
      "gz  6  7  8\n",
      "Index(['bj', 'sh', 'gz'], dtype='object')\n",
      "None\n",
      "        a_ABC  b_ABC  c_ABC\n",
      "bj_ABC      0      1      2\n",
      "sh_ABC      3      4      5\n",
      "gz_ABC      6      7      8\n"
     ]
    }
   ],
   "source": [
    "df1=pd.DataFrame(np.arange(9).reshape(3,3),index=['bj','sh','gz'],columns=['a','b','c'])\n",
    "# df1 = pd.DataFrame(np.arange(9).reshape(3, 3), index = ['bj', 'sh', 'gz'], columns=['a', 'b',\n",
    "# 'c'])\n",
    "print(df1)\n",
    "print(df1.index)\n",
    "# df1.index=['beijing','shanghai','guangzhou']\n",
    "# print(df1)\n",
    "\n",
    "# 自定义map函数（x是原有的行列值）\n",
    "def test_map(x):\n",
    "    return x+'_ABC'\n",
    "# inplace：布尔值，默认为False。指定是否返回新的DataFrame。如果为True，则在原df上修改，返回值为None。\n",
    "print(df1.rename(index=test_map, columns=test_map, inplace=True))\n",
    "print(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "1af777c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   X  Y  S  Z\n",
      "0  0  0  a  1\n",
      "1  1  1  b  1\n",
      "2  2  2  c  2\n",
      "3  3  3  d  2\n",
      "4  4  4  e  2\n",
      "   0  0  a  1\n",
      "0  0  0  a  1\n",
      "1  1  1  b  1\n",
      "2  2  2  c  2\n",
      "3  3  3  d  2\n",
      "4  4  4  e  2\n"
     ]
    }
   ],
   "source": [
    "df1=pd.DataFrame({'X':range(5),'Y':range(5),'S':list(\"abcde\"),'Z':[1,1,2,2,2]})\n",
    "print(df1)\n",
    "# 指定一列为索引 (drop=False 指定同时保留作为索引的列)\n",
    "result = df1.set_index('S',drop=False)\n",
    "result.index.name=None\n",
    "# print(result)\n",
    "result = df1.set_axis(df1.iloc[0],axis=1,inplace=False)\n",
    "result.columns.name=None\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "711206fb",
   "metadata": {},
   "source": [
    "有如下数据：\n",
    "data = {'id': [1,2,3,4,5,6,7,8],\n",
    "'name': ['张三', '李四', '王五', '赵六', '李琦', '张芬', '乔治', '江杰'],\n",
    "'sex': ['男', np.nan, '男', '男', '女', '女', '男', '女'],\n",
    "'age': [30,66,np.nan,37,28,102,63,35]}\n",
    "现需求如下：\n",
    "1.将题目中的 data 以 dataframe 形式进行存储，然后打印该 dataframe\n",
    "2.将 age 列含有空值的位置用 age 列平均值进行填充（在原 dataframe 上进行修改）\n",
    "3.将含有空值的行删除（在原 dataframe 上进行修改）\n",
    "4.增加一列：salary，salary 值随机生成，范围在 3000----5000 中间\n",
    "5.以 name 列为横轴，age 为纵轴，绘制柱状图，并且在每一个柱子上方标明 age 值（age 值保留成整数）\n",
    "6.将该 dataframe 按照 salary 一列进行降序排列（在原数据上进行修改）\n",
    "7.将该 dataframe 中性别一列进行修改，将男替换成 1，女替换成 0（在原数据上进行修改）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "f74f86cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   id name sex         age  salary\n",
      "6   7   乔治   男   63.000000    4819\n",
      "2   3   王五   男   51.571429    4813\n",
      "3   4   赵六   男   37.000000    4810\n",
      "7   8   江杰   女   35.000000    4554\n",
      "0   1   张三   男   30.000000    3597\n",
      "4   5   李琦   女   28.000000    3423\n",
      "5   6   张芬   女  102.000000    3233\n",
      "   id name  sex         age  salary\n",
      "6   7   乔治    1   63.000000    4819\n",
      "2   3   王五    1   51.571429    4813\n",
      "3   4   赵六    1   37.000000    4810\n",
      "7   8   江杰    0   35.000000    4554\n",
      "0   1   张三    1   30.000000    3597\n",
      "4   5   李琦    0   28.000000    3423\n",
      "5   6   张芬    0  102.000000    3233\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABQQAAAINCAYAAABoNnLdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAxOAAAMTgF/d4wjAABDHElEQVR4nO3de7xnc6E//td7jBmjcQmjhk0qpHQhdOLUUFHKIGM0dCFddEf07Zzq+EmnlHOiTpw0oSh0kumcXErFSUdF6KISoQtm3GluzBjG+/fH+uyxZ8+eMZd9mdnr+Xw8Po+991rvtdb787B85v15rfel1FoDAAAAALTDiKGuAAAAAAAweASCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWGTnUFejL6NGj67hx44a6GgAAAACwRpoxY8aCWuvovvatloHguHHjMn369KGuBgAAAACskUop9y9tnyHDAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAABrjLlz5+b444/P3nvvnY022iillJx99tl9lr3pppuy9957Z+zYsdloo43ytre9Lffff/9iZW6++eZ89KMfzQ477JD11lsv48ePzz777JPrr79+EN4NAAwNgSAAALDGeOCBB/KpT30qN910U17ykpcstdz06dMzYcKE3HbbbTnxxBPzkY98JJdeemn22muvLFiwYFG5M888M2eccUZ23nnnnHzyyTnmmGPypz/9KS9/+ctz+eWXD8ZbAoBBN3KoKwAAALC8xo8fn7vvvjvPfOYzc/3112eXXXbps9yJJ56Yhx9+OL/61a+y5ZZbJkle9rKXZa+99srZZ5+dI444IklyyCGH5JOf/GTGjh276Nh3vOMdef7zn59PfvKT2XPPPQf+TQHAINNDEAAAWGOMHj06z3zmM5+y3LRp0zJx4sRFYWCS7Lnnntl2221zwQUXLNq20047LRYGJsnGG2+cV77ylbnpppv6r+IAsBoRCAIAAMPKjBkzct9992XnnXdeYt/LXvay/OY3v3nKc9xzzz3ZZJNNBqJ6ADDkBIIAAMCwcvfddydphhf3Nn78+Dz00EN59NFHl3r8VVddlauvvjpTpkwZsDoCwFASCAIAAMPKvHnzkjTDi3tbZ511FivT23333Zc3v/nNefazn52PfvSjA1dJABhCFhUBAACGlTFjxiRJn70A58+fv1iZnh5++OFMnDgxc+bMyc9+9rMl5hYEgOFCIAgAAAwr3UOFu4cO93T33Xdno402WqL34IIFCzJp0qT87ne/yw9/+MO88IUvHJS6AsBQEAgCAADDyuabb55x48bl+uuvX2Lftddemx122GGxbU888UQOPfTQXHHFFbnggguy++67D1JNAWBomEMQAAAYdg488MBccsklufPOOxdtu+KKK3LLLbfkoIMOWqzshz70oXz729/Ol7/85UyaNGmwqwoAg67UWoe6Dkvo6uqq06dPH+pqAAAAq6HTTjstM2fOzF133ZXTTz89kyZNyo477pikCfc22GCD3Hnnndlxxx2z4YYb5qijjsrcuXPz7//+7+nq6sp11123aMjwF7/4xXz4wx/Orrvumve///1LXOuAAw7I0572tEF9fwDQH0opM2qtXX3uEwgCAABrkq222iq33357n/v++te/ZquttkqS3HjjjTnmmGPys5/9LKNGjco+++yTk08+Oc94xjMWlX/729+ec845Z6nX6nk+AFiTCAQBAAAAoEWWFQiaQxAAAAAAWsQqwwAAwEopJ5ShrsKwVY9f/UZyATB86CEIAAAAAC0iEAQAAACAFhEIAgAAAECLCAQBAAAAoEWWKxAspXyplPK3UkotpezQY/s2pZRflFJuKaVcV0rZfnn2AQAAAABDY3l7CF6Y5BVJbu+1fWqSr9Zat01yUpKzl3MfAAAAADAElisQrLX+X611es9tpZRNk+yc5NzOpmlJtiilbL2sff1TbQAAAABgZazKHIJbJLm71vp4ktRaa5I7kmz5FPsAAAAAgCGyWiwqUko5ppQyvfs1d+7coa4SAAAAAAxLqxII3plkfCllZJKUUkqaHoB3PMW+JdRaT6m1dnW/xo4duwrVAgAAAACWZqUDwVrrfUl+neStnU0HJplea71tWftWpbIAAAAAwKoZuTyFSilTk+yT5JlJflhKmVNr3TrJe5KcXUr5eJLZSQ7vcdiy9gEAAAAAQ2C5AsFa63uWsv1PSXZd0X0AAAAAwNBYLRYVAQAAAAAGh0AQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0SL8EgqWUN5RSfl1K+W0p5Q+llMM62zctpVxWSrm1s31Cf1wPAAAAAFg5I1f1BKWUkuTcJHvUWn9XStkqyc2llO8m+VySa2qte5dSdkny36WUZ9daH1vV6wIAAAAAK66/hgzXJBt2fl8/yYNJHk3ypiRfSZJa63VJ7kqyez9dEwAAAABYQavcQ7DWWkspU5J8t5TycJKnJ5mUZL0ka9da7+lR/G9JtlzVawIAAAAAK2eVewiWUkYm+Zckk2qtz0rymiTfzAqEjaWUY0op07tfc+fOXdVqAQAAAAB96I8hwzsk2azW+n/JoqHB05O8OMnjpZRn9ii7VZI7ep+g1npKrbWr+zV27Nh+qBYAAAAA0Ft/BIJ3JhlfSnl+kpRStk7y3CR/SvKdJO/tbN8lyeZJftoP1wQAAAAAVkJ/zCF4bynliCQXlFKeSBMyfrDWekcp5Z+SfLOUcmuSBUneaoVhAAAAABg6qxwIJkmt9VtJvtXH9nuTvLY/rgEAAAAArLr+GDIMAAAAAKwhBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAwBH79619nv/32y0YbbZR11103L3zhC/OlL31p0f4TTzwxL3/5yzNu3Liss8462WabbXL00Ufn/vvvH8JaA8PByKGuAAAAALTNj370o+y7777Zcccdc9xxx2Xs2LH585//nOnTpy8q86tf/So77LBDDj744Ky33nq56aabcsYZZ+TSSy/Nb3/72zztaU8bwncArMkEggAAADCIZs+enUMPPTT77LNPLrzwwowY0ffgvWnTpi2xbdddd83kyZNz8cUX5+CDDx7oqgLDlCHDAAAAMIjOP//83HvvvfnMZz6TESNG5OGHH84TTzyxXMdutdVWSZKZM2cOXAWBYU8gCAAAAIPo8ssvz/rrr58ZM2bkec97XsaOHZv1118/73vf+zJ//vzFytZa88ADD+See+7JVVddlSOPPDJrrbVW9thjj6GpPDAsGDIMAAAAg+jWW2/N448/nv333z/vfOc789nPfjZXXnllTj311MycOTPf+ta3FpW99957M378+EV/d3V15fzzz8922203FFUHhgmBIAAAAAyiuXPn5pFHHsl73/veRasKT5o0KQsWLMjUqVPzqU99Kttss02SZKONNsqPf/zjzJ8/P7/5zW/y3e9+N3Pnzh3K6gPDgEAQAAAABtGYMWOSJIcccshi29/85jdn6tSpufrqqxcFgqNGjcqee+6ZJJk4cWJe85rX5B//8R+z6aabZuLEiYNbcWDYMIcgAAAADKLNNtssSfKMZzxjse2bbrppkuTvf//7Uo/dbbfdMn78+Jx33nkDV0Fg2BMIAgAAwCDaaaedkiQzZsxYbPtdd92VJBk3btwyj58/f35mzZo1MJUDWkEgCAAAAIPoTW96U5LkrLPOWmz7mWeemZEjR2aPPfbIww8/nEceeWSJY6dNm5a///3v2XnnnQelrsDwZA5BAAAAGEQ77rhj3vGOd+RrX/taHn/88ey+++658sor853vfCcf+9jHstlmm+W3v/1t9txzz0yZMiXbbbddRowYkeuvvz7nnntuttpqqxx11FFD/TaANZhAEAAAAAbZV77ylWy55Zb5+te/nv/+7//Os571rHzhC1/I0UcfnSTp6urKgQcemP/93//NOeeck8ceeyzPetaz8sEPfjCf+MQnsvHGGw/tGwDWaKXWOtR1WEJXV1edPn36UFcDAABYhnJCGeoqDFv1+NXvexoAa5ZSyoxaa1df+8whCAAAAAAtYsgwAAAArVB0ah0wq+HgQ2AZ9BAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAt0i+BYClldCnltFLKraWU35dSzu1s36aU8otSyi2llOtKKdv3x/UAAAAAgJUzsp/O87kkNcm2tdZaSnlmZ/vUJF+ttZ5dSpmc5Owku/TTNQEAAACAFbTKPQRLKU9L8s4kn6i11iSptd5TStk0yc5Jzu0UnZZki1LK1qt6TQAAAABg5fTHkOHnJnkoycdLKdeXUq4qpbwmyRZJ7q61Pp4knbDwjiRb9sM1AQAAAICV0B+B4Mgkz0ryx1rrzkmOTPLtrMBw5FLKMaWU6d2vuXPn9kO1AAAAAIDe+iMQvCPJE0nOS5Ja62+S/DVNSDi+lDIySUopJU3vwDt6n6DWekqttav7NXbs2H6oFgAAAADQ2yoHgrXWB5JckeR1SVJKeXaSZyf5eZJfJ3lrp+iBSabXWm9b1WsCAAAAACunv1YZfm+Ss0opJ6XpLfieWuuMUsp7kpxdSvl4ktlJDu+n6wEAAAAAK6FfAsFa61+SvKqP7X9Ksmt/XAMAAAAAWHX9MYcgAAAAALCGEAgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBIE1ypVXXplSSp+va665ZlG5H/3oR3nnO9+ZF77whVlrrbWy1VZbDV2lAQAAYDUycqgrALAyjjzyyOyyyy6Lbdt6660X/X7++efn29/+dl760pdms802G+zqAQAAwGpLIAiskV75yldm8uTJS91/4okn5owzzsjaa6+diRMn5g9/+MMg1g4AAABWX4YMA2usOXPm5PHHH+9z32abbZa11157kGsEAAAAqz+BILBGOvzww7P++utnnXXWyate9apcf/31Q10lAAAAWCMYMgysUUaNGpUDDzwwb3jDG7LJJpvkj3/8Yz7/+c/nla98ZX7xi19kxx13HOoqAgAAwGpNIAisUXbbbbfstttui/7eb7/9Mnny5Lz4xS/Oxz72sVx22WVDWDsAAABY/RkyDKzxtt566+y///75yU9+koULFw51dQAAAGC1JhAEhoUtttgiCxYsyMMPPzzUVQEAAIDVmkAQGBb+8pe/ZJ111snYsWOHuioAAACwWhMIAmuU+++/f4ltN9xwQy666KK89rWvzYgRPtYAAABgWSwqAqxRpkyZkjFjxmS33XbLpptumj/+8Y/56le/mnXXXTef+9znFpX73e9+l4suuihJctttt2XWrFn59Kc/nSR5yUtekn333XdI6g8AAABDTSAIrFHe+MY35rzzzsspp5yS2bNnZ9y4cZk0aVKOP/74bL311ovK/frXv85xxx232LHdfx922GECQQAAAFqr1FqHug5L6OrqqtOnTx/qagAAAMtQTihDXYVhqx6/+n1PGw6KW3bArIbRArReKWVGrbWrr30m2wIAAACAFjFkGFguegAMDE//AQAAGGx6CAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBYRCAIAAABAiwgEAQAAAKBFBIIAAAAA0CICQQAAAABoEYEgAAAAALSIQBAAAAAAWkQgCAAAAAAtIhAEAAAAgBbpt0CwlHJ4KaWWUt7Y+XvTUsplpZRbSyl/KKVM6K9rAQAAAAArp18CwVLKVkneneSaHps/l+SaWus2SQ5Pcn4pZe3+uB4AAAAAsHJWORAspYxIcmaSDyV5tMeuNyX5SpLUWq9LcleS3Vf1egCwJrnxxhtz0EEH5TnPeU7WXXfdbLLJJpkwYUIuvvjixcqVUpb62muvvYao9gAAwHA0sh/OcUySn9daf1VKSZKUUjZOsnat9Z4e5f6WZMu+TlBKOaZzniTJBhts0A/VAoChd/vtt2fOnDk57LDDstlmm+WRRx7JtGnTst9++2Xq1Kk54ogjkiTf/OY3lzj2+uuvz3/8x3/kta997WBXGwAAGMZKrXXlDy7lhUnOSDKh1vpYKeXKJF9MclWSu2qto3uUvSDJZbXWrz3Vebu6uur06dNXul5A/ysnlKGuwrBUj1/5z2DWXAsXLsxOO+2U+fPn5+abb15quXe961352te+ljvuuCNdXV2DWEOA5aN9MHC0EQZGccsOmFWIFoABUkqZUWvt84vEqg4ZfmWSrZLcWkr5W5KXJ/lqmuHCj5dSntmj7FZJ7ljF6wHAGm+ttdbKFltskZkzZy61zKOPPppp06Zl9913FwYCAAD9apWGDNdaT09yevff3T0Ea63/U0r5hyTvTfLJUsouSTZP8tNVuR4ArKkefvjhzJs3L7NmzcpFF12UH/zgB5kyZcpSy3//+9/PzJkz85a3vGUQawkAALRBf8whuDT/lOSbpZRbkyxI8tZa62MDeD0AWG0de+yxmTp1apJkxIgRmTRpUk477bSllj/vvPMyevToTJ48ebCqCAAAtES/BoK11j16/H5vErOgA0CSo48+OpMnT85dd92VCy64IAsXLsyCBQv6LDt79uxceumlecMb3pANN9xwcCsKAAAMe6s6hyAAsBy222677Lnnnjn00ENzySWXZO7cudl3333T1+Je06ZNy/z58w0XBgAABoRAEACGwOTJk3PdddfllltuWWLfeeedlw022CATJ04cgpoBAADDnUAQAIbAvHnzkiSzZs1abPvdd9+dn/zkJznwwAMzevTooagaAAAs4cYbb8xBBx2U5zznOVl33XWzySabZMKECbn44osXK/f2t789pZQlXtttt90Q1Zy+DOSiIgDQevfdd1823XTTxbY99thj+cY3vpExY8bkBS94wWL7/uu//itPPPGE4cIAAKxWbr/99syZMyeHHXZYNttsszzyyCOZNm1a9ttvv0ydOjVHHHHEorKjR4/OmWeeudjxG2ywwWBXmWUofc1dNNS6urrq9OnTh7oaQA/lhDLUVRiW6vGr32cw/euAAw7I7NmzM2HChGy++ea55557ct555+Xmm2/OySefnGOOOWax8jvvvHPuvvvu3HnnnRkxQkd+YPWmfTBwtBEGRnHLDpjVMFpgECxcuDA77bRT5s+fn5tvvjlJ00PwwgsvzNy5c4e4dpRSZtRau/ra55sGAAygKVOmZMSIETn99NPzvve9L6ecckq6urryve99b4kw8E9/+lN+9atf5eCDDxYGAgCw2ltrrbWyxRZbZObMmUvsW7hwYWbPnj34lWK5GDIMAAPo4IMPzsEHH7xcZZ/3vOf1ueowAACsLh5++OHMmzcvs2bNykUXXZQf/OAHmTJlymJlHnnkkay//vp55JFH8vSnPz2HHHJITjrppIwdO3aIak1vAkEAAAAAlsuxxx6bqVOnJklGjBiRSZMm5bTTTlu0f/z48fnoRz+al770pXniiSdy2WWX5ctf/nJuuOGGXHnllRk5UhS1OvBfAYBhyRxBA0cnRgCA9jr66KMzefLk3HXXXbnggguycOHCLFiwYNH+z372s4uVP/jgg7PtttvmE5/4RC688MLlHj3DwDJBEQAAAADLZbvttsuee+6ZQw89NJdccknmzp2bfffdd5lT33z4wx/OiBEjcvnllw9iTVkWgSAAAAAAK2Xy5Mm57rrrcssttyy1zJgxY7LxxhvnoYceGsSasSwCQQAAAABWyrx585Iks2bNWmqZOXPm5IEHHsi4ceMGq1o8BYEgAAAAAMt03333LbHtscceyze+8Y2MGTMmL3jBCzJ//vzMmTNniXL/+q//mlpr9t5778GoKsvBoiIAAAAALNN73vOezJ49OxMmTMjmm2+ee+65J+edd15uvvnmnHzyyRk7dmz+9re/Zccdd8whhxyS7bbbLknywx/+MN///vez9957Z//99x/id0E3gSAAAAAAyzRlypScddZZOf300/Pggw9mvfXWy0477ZSTTjop++23X5Jkww03zMSJE/PjH/8455xzThYuXJitt946J554Yj7ykY9kxAgDVVcXZVmrwAyVrq6uOn369KGuBtBDOaEMdRWGpXr86vcZPFwUt+yAWQ2bDsAQ0T4YONoIA0P7YOBoH8Dqp5Qyo9ba1dc+0SwAAAAAtIghwwAAAACrK11bB0bLu7XqIQgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iECwxW688cYcdNBBec5znpN11103m2yySSZMmJCLL754ibI33XRT9t5774wdOzYbbbRR3va2t+X+++8fgloDAAAAsCpGDnUFGDq333575syZk8MOOyybbbZZHnnkkUybNi377bdfpk6dmiOOOCJJMn369EyYMCEbbLBBTjzxxMydOzef//zn8/vf/z7XXnttRo0aNcTvBAAAAIDlVWqtQ12HJXR1ddXp06cPdTVaaeHChdlpp50yf/783HzzzUmS97///Tn77LNz8803Z8stt0ySXH755dlrr70WCw4Z3soJZairMCzV41e/z+DhorhlB8xq2HQAhoj2wcDRRhgY2gcDR/tgALlxB0YLbtpSyoxaa1df+wwZZjFrrbVWtthii8ycOXPRtmnTpmXixImLwsAk2XPPPbPtttvmggsuGIJaAgAAALCyDBkmDz/8cObNm5dZs2bloosuyg9+8INMmTIlSTJjxozcd9992XnnnZc47mUve1m+//3vD3Z1AQAAAFgFAkFy7LHHZurUqUmSESNGZNKkSTnttNOSJHfffXeSZPz48UscN378+Dz00EN59NFHM3r06MGrMAAAAAArTSBIjj766EyePDl33XVXLrjggixcuDALFixIksybNy9J+gz81llnnUVlBIIAAAAAawZzCJLtttsue+65Zw499NBccsklmTt3bvbdd9/UWjNmzJgkyaOPPrrEcfPnz0+SRWUAAAAAWP0JBFnC5MmTc9111+WWW25ZNFS4e+hwT3fffXc22mgjvQMBAAAA1iACQZbQPUx41qxZ2XzzzTNu3Lhcf/31S5S79tprs8MOOwxy7QCAgXTdddflgx/8YLbffvs87WlPy5Zbbpk3velNueWWW5Yoe8EFF+TlL395Ntxww2y88cbZfffdc+mllw5BrQEAWBECwRa77777ltj22GOP5Rvf+EbGjBmTF7zgBUmSAw88MJdccknuvPPOReWuuOKK3HLLLTnooIMGrb4AwMA76aSTMm3atLzmNa/Jf/zHf+SII47I//3f/+WlL31p/vCHPywqd+qpp2bKlCnZZJNN8rnPfS7HHXdcZs2alYkTJ+a73/3uEL4DAACeSqm1DnUdltDV1VWnT58+1NUY9g444IDMnj07EyZMyOabb5577rkn5513Xm6++eacfPLJOeaYY5Ikd955Z3bcccdsuOGGOeqoozJ37tz8+7//e7q6unLdddcZMtwS5YQy1FUYlurxq99n8HBR3LIDZjVsOtCPfvGLX2TnnXfOqFGjFm279dZb86IXvSiTJ0/OueeemyTZdttts+GGG+aXv/xlSud/uNmzZ2fzzTfPq1/96nzve98bkvozuLQPBo42wsDQPhg42gcDyI07MFpw05ZSZtRau/raZ5XhFpsyZUrOOuusnH766XnwwQez3nrrZaeddspJJ52U/fbbb1G5LbbYIj/96U9zzDHH5J//+Z8zatSo7LPPPjn55JOFgQAwzOy2225LbNtmm22y/fbb56abblq0bfbs2dl2220XhYFJsv7662fs2LEWHAMAWM0JBFvs4IMPzsEHH7xcZbfffvv88Ic/HOAaAQCro1pr7r333my//faLtu2xxx658MILc+qpp2bffffN/Pnzc+qpp2bWrFk56qijhrC2AAA8FYHgUNDdd+C0oMsvAAy28847LzNmzMinPvWpRdu+9KUv5YEHHsiRRx6ZI488MkmyySab5Iorrsiuu+46VFUFAGA5CAQBAFiqm2++OR/4wAey66675rDDDlu0fd11183znve8dHV1ZeLEiZkzZ06+8IUvZNKkSbnqqquy9dZbD2GtAQBYFoEgAAB9uueee7LPPvtkgw02yIUXXpi11lpr0b6DDjooI0eOzMUXX7xo2/77759tttkmn/jEJ/Ltb397KKoMAMByGDHUFQAAYPUza9asvP71r8/MmTNz2WWXZbPNNlu07y9/+Usuu+yyxRYhS5KNNtoor3jFK/Lzn/98sKsLAMAK0EMQAIDFzJ8/P/vuu29uueWWXH755XnBC16w2P577703SbJw4cIljn3sscfy+OOPD0o9AQBYOXoIAgCwyMKFCzNlypRcffXV+c53vtPnAiFbb711RowYkW9/+9upPRb0mj59eq666qrsuOOOg1llAABWkB6CAAAscuyxx+aiiy7Kvvvum4ceeijnnnvuYvvf+ta3Zty4cXnHO96RM888M695zWsyadKkzJkzJ1/+8pczb968fOxjHxui2gMAsDxKz6e6q4uurq46ffr0oa7GwCllqGswfK2G9/NwUU5w3w6Eerx7dqD4qB04PmqHtz322CM//elPl7q/u+34+OOP5ytf+UrOOuus3HbbbUmSXXbZJccdd1xe9apXDUpdGXraBwNHG2FgaB8MHO2DAeTGHRgtuGlLKTNqrV197hMIDgH/Mw+c1fB+Hi40+AeGxv7A8VE7cHzUAt20DwaONsLA0D4YONoHA8iNOzBacNMuKxA0ZBgAYHWgsT9wWtDgBwBYERYVAQAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALbLKgWApZZ1Syv+UUm4ppdxQSvlxKWXrzr5NSymXlVJuLaX8oZQyYdWrDAAAAACsrP7qIfjVJM+rtb4kyfeSnNnZ/rkk19Rat0lyeJLzSylr99M1AQAAAIAVtMqBYK11fq31+7XW2tl0TZKtOr+/KclXOuWuS3JXkt1X9ZoAAAAAwMoZiDkEj0ryvVLKxknWrrXe02Pf35JsOQDXBAAAAACWw8j+PFkp5eNJtk7ymiRjVuC4Y5Ic0/33Bhts0J/VAgAAAAA6+q2HYCnlI0kmJXl9rfWRWuuDSR4vpTyzR7GtktzR+9ha6ym11q7u19ixY/urWgAAAABAD/0SCHZ6+B2SZK9a68weu76T5L2dMrsk2TzJT/vjmgAAAADAilvlIcOllK4kJyf5S5KflFKS5NFa6z8k+ack3yyl3JpkQZK31lofW9VrAgAAAAArZ5UDwVrr9CRlKfvuTfLaVb0GAAAAANA/BmKVYQAAAABgNSUQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALSIQBAAAAIAWEQgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0iEAQAAAAAFpEIAgAAAAALTLggWApZZtSyi9KKbeUUq4rpWw/0NcEAAAAAPo2GD0Epyb5aq112yQnJTl7EK4JAAAAAPRhQAPBUsqmSXZOcm5n07QkW5RSth7I6wIAAAAAfRvoHoJbJLm71vp4ktRaa5I7kmw5wNcFAAAAAPowcqgrkCSllGOSHNNj08JSyj1DVR8WMzbJ3KGuxHIrZahrwOphjblvyyfdsyRZg+7ZxEcti6w5962blsaac89GG4FF1pj71kctHWvMPduSm3bc0naUptPewOgMGb4tyUa11sdLKSXJ3UleUWu9bcAuTL8ppUyvtXYNdT1gRbhvWdO4Z1kTuW9Z07hnWRO5b1nTuGfXHAM6ZLjWel+SXyd5a2fTgUmmCwMBAAAAYGgMxpDh9yQ5u5Ty8SSzkxw+CNcEAAAAAPow4IFgrfVPSXYd6OswYE4Z6grASnDfsqZxz7Imct+ypnHPsiZy37Kmcc+uIQZ0DkEAAAAAYPWyWqwyDJAkpZTXJ9k6yYLOa3meWKydZHSSv9VaL+lxrq4kGyV5bDnP022dJA/XWm9dgWMAAABgjSEQBFYnb+m8Vsa0JJf0+PtdSY5fyXN9O8nBK3kswBqtlPK6JDNrrb8c6rpAkpRSRqd5ADi/1vp4H/ufleQ/k5xRa/1ej+1PTzKy1nr/U5z/50ker7Xu3mv7n5P8otb6tn54G7BMpZS1k+yQ5JZa66yVPMfGtdYH+7ViMABKKTsleaTWetNQ16XNBnSVYYZOKWV0KWVsKaXP0LeU8qxSyiWllP17bX96KWXc4NQSlvDBJM9I8vQkT0sypsfr4iR39No2JskGSTZN8u5e5zopyXppvgiU7lea0PDantt67V83yTsH+o0yPJVSxpVSthzqesAqOjfJp/v7pKWU95VSLC7Hyjg8yZwkj5VSao/XmZ396yTZJ8nmvY77TJLbSinjuzeUUsYsq43cS0mPUQallLVKKU8rpayzSu+G1iiljCilvLDzelEpZadSyqtKKfuXUt5RSjmhlHJOJ5SeneTaJP+0lHM9s5TykWV8v1s7yR9KKReWUsYM3LtiOCulvLSUcnHnQctA+mWSM5+yFANKD8Hh6/AkpydJKaXn9rNqre/Kkw2n7/c67jNJ3lJK2a7Wenf3xs4X3E8meTTLN5SzJBnVuc4xtda/r/Q7oTVqrTOXtq+U8kRTpM7vtav3393nmreUU22Z5JZl1GFpx8HyOC3Ja9OE2stUShmzvPdbKeUtSWbXWi9exfpBOmFGV5J5SRb2UWRup9wz+9g3Is3DmAdWogfL29M82Pn6Ch4H30rywzT/5j/W2fa3NO3S9PEzpZQXJTkiyVd7tmmTfKLz6t1GTimlr/bts0spvXsIfizJ51b0TdA+tdYnSinnJXlxZ9OCNOH2/DQB9h+T/CXJbUmu6+x7qJQyotb6RK/TvSPNd7VDSilvqbXe3Gv/m5M8M8lvtWdZBbsleX2SP5ZSjk/yxST/mmYqpgVZst3Q3aFibJLUWg9ZzussyFK+xzF4BILDV382nJLmy+3bOuUfzfLNyTYyzZeGf0kiEGR1sWWSy4e6Egxb89Ljc7VbKWXjNEPdHu6x+fullDlJ3l1rvXdpJyylbJ5kapqeMTvWWv/Wz3WmfV6Y5ovnsmyVpHdboKe3lVJuSjIxi9/z3V8MvpymHdD9BaKmM+drKWW7Ttm1kzxaa13qQxpIkk74vFgA3QnzFnT+XNjzZ2l2finJ9CQf7XW6LyQ5K4u3kS/t/H1gr7LXJvlVkvd1/l47zcPulRrOSWvtmeZhyqzuB9ullDcm+e8kB9daf788J6m1nlhKuTPN5+v1pZQDaq0/7pxvVJqpcq5JcmL3MaWUkX0Ns4elqbWeVkq5Lsl3knw2zfem/ZM8N0/O8z4qTQA4O83n6KjOa1E7t3NPjkrTRni8Lrma7aN58jN4MZ3P8NFpFsEVbg8ggeAw1c8Np9Rab0jTCII1RmfOoZrksVprLaWsl2TDND1UoF+UUl6c5vNxQZph6rWU8vwka6X54nhHkhvSNPzf3zlmdJJd0/QKuG9Z56+1ziilfCDJ2UnOL6W8oo9eA7AibkoTCj6UJgSpaT4bL00T5q2b5Ddpeqpsn+TVefIp/qhO2QeSvDTJS9Lc+69OE4hfnaYRPyZNj8AP58lAcOMkz0vys8651kpyZZIDBuJN0iq9v2gen2RCktfWWucuVrCZX22xOdY6Qy3n1Fof6LW9JFmr93ZYHqWU9dO0D2bVWhf02v2GJPcn+cMyjh+VZO2eDxNrrd8spfwxTa+ta3sU/3CaaXde391GKKXskuSCUsq+tdalXgd6q7X+sjPH36tqrb9N8oKe+0sp70pyRpL9a61XLuU0k9J0Uuo+pq8yr1tKz+xuJyX55+WvOStKINhey91wgsHUCUpGp/MEalnBR6cBPzpN4LdEr6wk/y9NF/fe/wh9sZTyxT7Kv7/WevpKVp32+kaaUKSnP/b4/fmdMv+vlDKt1npFkn9Ic++e1ccT0yXUWs8ppRyS5HVJPpTkP/ql5rRS58vljd1/d1ZlvzDJZkn+MclFSR5PM2rghjRTkLy5x1P67hD78s4rpZQrk9xTa+25INP/13mlM3fg19KMVvhMkgv0WmF5ddoGz+69OU1A3bvs69Pcd5/ufN4uj6OTfLbnggyllO8nuSfNMExYGceks8DdUsKQJHliGfuS5HtJ3thzQ631V0le2f13KWX7znXeV2v9U4+it3Z+/ncpZada6+wVqTzt1lmM6YJVOMV1aYa5z0/Tpuhu7/5rknFpHpr/Pc0UJl9I8osex45I8/ne835mAAgEh6lBaDjBQHlbmidOSZZ7fp8PpZm7rbevp/li+1iaf4TelOSENPNn/qVHue3S9N6yKhsrY0KSJ9KE2F9OMzTo2Xmyh+AjaeZgPSDJVzsN99enuS+/uQLXOTrNZ/X/9E+1YdGwtTPS3K971Vr/2JmMfmSt9e+llH2SXJbkV6WUf0py6Yr2UO3MgXl6klOSzEizGuxJpZTPpAnF+xwyBD28KH0Pcx/dx7Z10kybc8LynLjTi+vUNMPhts6TbYGpaT5vj0tnzkFYQf+V5Ko0vbF7Dnv8aJqgea80vQQvSNPzemKeHM2VNEMya5KUUt6R5uHjCbXWh7oLlFJekGZO+K/VWs/pefFa68zOCINL0zyQmdyP741hqJTyviQ31Fp/8ZSFn0Kt9c9J/tzr/Hul+d712TQPHW9MM5Lm9Uk+tpQOHgwggeDwNWANJxhgv0/y+TQNokfTBC1J03Aan+TkHmVHpbmnf9vXiWqtM9J8+UzSLOKQpmH1k57zUZRSNuz8amJbVljPJ+7dAXan19/j6SzOkGReKeU9Sf43zdCHNyb5Xq31vh7HvivJW9IM05ybJ+/9np5I8pk+ehOslWaI5h9rrR9f5TfFsFdK2S3Jp5K8Js0T+Df2mKB+gzRtg9Raf19KeXmS76Z5wHJnKeUnSX5aa/3aU1xjrzTDfV6c5FO11k91tp+TJoQ8Pc0X5VXpgUA7PK3z8/W11su6N5ZS1imlbJLOZPZp2gQ/TtNzdUzns7K7rfBw7x5SnfldL02yTZKJtdZfdu+rtX6vlPKFJB8vpcyttX52YN4aw1XnM3WxhT86n6dvS3JSrfWqzrb3pJlK4fBa64eXcroJSQ5LM3/rx5J8NcmOneOeSPJIKeVraRYVeUaSTTqvdTvHH1hKeU+tdWo/vkWGkc7n4RfSzPX7wyT/X6312qc4bEXP/+U0/+5/Pk0gmDQjun6WZGop5R2mxRlcAsHha6AaThukmRh/qel9KWVE5/i1DD9mRXUa47/svb2UsnOSdWutn16F0z83yd19TE47pvPTUylWSCnlZWk+bx9LMyfruDQNqZen6ZW9VprP1NtrrT8ppfx3mp4mI9P0bO1p8zTDNbvD8OVZvGlRVdLMU9TXirGwSCllZJKfJHlFmi+RlyT5eJK5naHDSTOR+J09/q5p5gLaJ8lRSQ5NMqeU8p00PV/np/niObKUMiXNJONXd47bIM2X39/0WEwknWteleTGzjxFv+9jji3o1t1u7T3kcc8kPVdf/0rn1ZfjkixqQ3Tuu2+lCU9e1x3O9PL/0vT4PrGU8sIkR5lPkJVVStk1TQD9y/S4F2utV5dSPp/ko52RMMf2nk6k1vr2Usp/pQlUvpIm6Dstzf8TT0/yqjS9sW5IM63DvWl6Hz6Qpk3x4yTHlVK+7rOWvtRaHyylvDLNvfm6JM8vpTy/1vrIqp67lDI2TU/WrZMcUGt9qMdD9F+UUk5M0z5ep5RyhOHtg0cgOHwNRMNpZJKZnd+Xpw6/TPLy5SkIg+S56dV1vWOdzk+BICvq35Ls3sf2q3v93f15+okk+6VZvXWxKRpqrSdET20GWK318VLK2WlWAvxYmoDvd0spflyvvw+vtT6/s2jOfWm+hH48zWfns9LMQfgvaXp6P5FmKob5aYZj9rZ2kvXT9IhdO82XhBl9lIOkWZAmSTbpFSzfmiYI2SDN8N5PJ/lBkp92fv9hnpy+4W9JUkp5Rpqe2h9I05P70CR/6jww78sHOse/OckbSinf6FzjcvNgsjxKKWulWVTsc0n+mmS/7tWGe/hskt3SLA7yD6WUD/funVVrvayUskOa3t1n1Fof6/T2vquP8/Wuw75pHooLA1mqWut1aRb6eGuSJ/opDHxOmpEAOyU5udb6P30UOy7Jc5IckmT3Ti/Y892vA08gOHz1W8OphyeSnJOmcb+sf3S65yq8a1XeAAyA56b5gtqbHoKsrMPz5ArDT6TpEfXjNE/l35JmUuR10gyPSI9y49M0/H++rJOXUtZJ8mjvngKdntgb9pxHCJZXrfWsJGclSSnl42nms5qXxXulbpqmgX5omlUwP51m4ZHUWm/qlHkwzVxAS1tUZN0sRSlljzQ9Fd9Qa/3Z0spBR3dY971e299faz29R2/WP3d6m9yYZFyt9ZqehTvBzIVJdkjzQOe2ND1in8qcNKvCfjzJkUke6TkCB/rSmdP9gDSfsTumuX9PTfLdUsqJtdYf9Sj+jTTtgi8neV+Sa0opv0zyjZ4L3nV6Th3d47h7k0xcjs4af6613r1q74i2qLWeu6rn6KyS/e40C4ltkGaYfM8Vg0d0Xqm11k4I+Zc0Dyu/nuSUUsq/1Vo/t6p1YekEgsNXvzSceuqM5397/1cVBl5n3ooN0ncPQYEgK6XW+tdSyoie852UUh5PE+Ld0cchX+z8fDzNatcve4pVhj+UZt6f99daf905/8ZpJiofVUp5lblWWBW11iUe3pVmFfZ3JbkzyZQk05ZnNeylnOeo3peM9icrqNZ6SppFaZIkpZSt0vS0mrmUQ36Y5LBOL6tFi9bUWheWUiYmWbvW+kApZe00n6dJMivJ8b2/fJZSfpxkk1rrD5L8oJTy3CTT++edMcx9PU2Pp4fS/Hv+n2kWT9g9TUjY07wk82qtH+hMx/CZNAHhhb1PWko5LMk1nRWFN87yhdpfSvKblXwftFAp5fA0nYAuqLWuzJQ0r0tz381P8u5a65m99j8tT47S6s4a/qUzvc6/pll055KVqTvLb8RQV4CBUWs9pdZaul95csXhmUs55IdJJncaRrBGK6WsW0oZVRZ/XPrczs9lBoKlMaqU8rQ+ykFfTiylXFtKeW2PbeuWUl5QSnlJKWXLZFEDfmKaoT6nJdk5TS/CPpVm5ctjk/xDkpf22DU/zaThE9IMe4MVUkp5eill/VLK6FLKyN6vNE/0f5amF9X/JFmrs29057jNO8Mun8q8NL1Xnt95/VuasFyIzarq/hI5cyn7z0kzN+DhvXfUWmd1zwNYa32sM9TyJWlGt/Se7iFpesve3uP4P1sJk+X0jjS9Sp9baz2t82DlmZ19vdujj6XzYLrWemWt9R+T7Jqmx+AinbbtCWlWwU6eHLX1n3nys7bna89e5WB5fTjJuUletjIH11ovTvLWJC/sHQaWZqHHq9OMQOh93K9qrW9IsmmtdYn99C9PaNtjeRpOH03TcPrqYFQIeuqssPbsNEMq+5ovYtskG5RS/qWPfWulWchmRq31P9MMuziwc97eZc8vpZy/lGr0/Efnp0n2WN7602qbJNklzZxq3XZNcmPn95M799zpSa5JM0/Q+ml6XJ9YSrlwKXP/fDrNF9qLejakaq0Pl1ImJbk+yQmllP8z5JIVdFWS7Z+izOuy7C+QU5O8t/fGznD2SWnu9YVJHu9evbiUcn8sfEP/WL/z8+997ay1/rHTy+RzpZQf1Vr/9hTnOybNHJZ9TeOwRZo2AayQzr/tvVenfmmSmbXWB/s6pNfxfY3c2ifNnK3v7Pzd3WZ+oD65UvwipZTuz/HHeu+DpSml7J7kRUm+Vmvt60HJcqm1fqv3/KydkTXz0vme1XnAOKrWemfn739MMyz+3St7XZafQLA9+rvhBP3twDRDKLoDwb6Gpy3M4vOmdBuZJhC8Ls0T0ivSzEExLyveABrROZ85MFleW3V+bp7kt53fr0jy2jT30ouTXJbmgczkzrCLv5dS/i3JiWmGEf17zxOWUvZKM5H9vWmGbi6m1nprKeXdSb6d5FullB2W8uUC+vK6zs9H0wxf7+32NCthvr/X9hF58gFM77BwRJper7elebizf2fbyB5zGY+L0Sn0j806P+/tvaOzGvBL0oR8NyT531LKq5fWtu08YHlTkiN7LxJSShmXZvGcv/Zf1WmrzkisA5L8YhVOc2yS39Zar3jKkrDyjknzXax3oL1COvf870spf0wzBPiQNA/Dd6213lVK2TRNb9nr82RHjN2TTE7zoP0Dq3J9nppAsD1WuuHUGbbWPSfWCj3Z7ww92jDNXC0msmWpaq2vfepSy32u05+6FPSbFyaZm+ScUsp+3Rs7wyIXdOZsnZlkUq215yqqX0qyZRZf+T2llC2SnJ8mOHlnrfX+vi5aa72gExy+K01vrcn99o4Y1nrdh0sopdQkC2qtM5+i3GZpegnul6bH4f+mGWJ8Sa31zlLKK9L0cr2px2F6CNIfXp7my2p323JU5+dhaXpjX11rPa+UcmiSaUl+Xkp5b2cIW5JFQ9Y+kuT/S3JRmqkc0unN8vQ081t1Dzm+YWDfDi3x+TTfyd6zMgd3ek7tkT4eFCYZ0fne1dtaK3Mt2quU8qIk+ya5rNZ62yqe7oA0w+S/VWt9opTyYJq274eSfKzWel9nFM27Sylvq7V+M83/J4cmOaKUcnKt9S+rWAeWoazEHNGsgUopn0szJHjdWuv80iz//eckV6ZpVF1da311KWX/NA2ne5O8t9Z6cSnlD3nqoUVP5ae11j1W8RwAq5VOo+l3SY5P8/DjyDQ9XK+utb6mR7myPIsylFLWSxOq7Jzk9Fpr7x5afZX/fZrhQ1NqrRes5FuBRUopc5JcWGtdYv61XuVGp5lf6MdpFh55sNf+dyf5h1rruzp/75zmy+wpaXrQ/iDJK2qty1xtG5KklLJBmpWpn57mM++3tdaXdvZ9IJ1AL800OMd234+llIPSTCVyf5Jdaq33llLen2YV7WekGVlwbK11Qaf8K9IMq+/2uyQ79e49CMurM5fwF9JMp3B+rXWJ+YNLKecm2bvWuknvfT3K/CzNQ8jNaq2PdLY9Pc2iJU/lM7XWvqbdgcWUUi5Ns6r6gbXW75ZSvpwmWF6Q5Ik0D2O2TzM/5bQ8ucjSWknWTpJa63tLs8rw75OMTzOP5v2d81+f5DlJumqtj3SGDP8lTY/A59VaF5RS3pRmFMxZ3W0IBoYegsPYUhpO3UN8Xt/5uUc6DackqbV+r5RySJqG03+WUq5N87T/qjRDL1d0IvCS5oOhr9U2AdZ03asEfqfWelMp5fdpVgZ8dSnlr0luTdPAmV2a1YefyJPD0kelWdBmgzSfwdOTfD9NGHhDml7by1RrnVNKeW+aYOXUUsrltdbl+WIAi+mE2yemmWJkbBafE7NPnYUVDlrG/jOSnNHj7+tLKTekWRFzp85mQ91ZLrXWWZ0vks9K007tudjC/WlCkbf37AXYOe47nc/mdWqt3SNlrkjTq/rAWusvepX/WSnl7DTDhK9OcqUwkJVVSjkuTfi8dpqAY2kPWkZmGd/NSynvS/KPSb7cHQZ2dM8Tf0WSy/s49Olp2iq+9/OUSikHpwkD78+TI1impGmvdgeC3XnAg3lymG/Jk4HgY2lGDxyYZg74f+o12uWsJB9M81l+U+chzWfTTL2zYZr2x4Vpwsbv9/d7ZHF6CA5zpZSvpvmf7Zo0/4Dc29n+pjRDKpZoOHX2b5em4fTbQawuwBqj89Dlb0luqbX+Q4/ta6fp/bR7mif5WyTZOE3IMjpNg6nkybnUHqy1blJK2SPJ99LMzfbyWutyz1lVSrkgya+TnFxrNXE4K6zT2+/BNPffNUne81RDi1fhWmcn2TrNgjn/NhDXoH1KKRt5IMLqptOT///ShIH/trRV1kspF6XpIThqKfufn+TkJP9Sa/11j+1bpQmvT6i1frKP47r3n1prPXKV3gzDXinldUn+Ocnvaq1H9cP5JiS5prsHdmfb2mkWHBNErQYEgi2m4QSwakopuyQZX2u9qJ/O97wko2utv1vB45ZrSDIsSyllbYEyQP/ybzRrmlLKOj1GFjKMCQQBAAAAoEVGPHURAAAAAGC4EAgCAAAAQIsIBAEAAACgRQSCAAAAANAiAkEAAAAAaBGBIAAAAAC0yP8P8cNzhnMmGh4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1600x640 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "from pandas import Series,DataFrame\n",
    "\n",
    "data = {'id': [1,2,3,4,5,6,7,8],\n",
    "'name': ['张三', '李四', '王五', '赵六', '李琦', '张芬', '乔治', '江杰'],\n",
    "'sex': ['男', np.nan, '男', '男', '女', '女', '男', '女'],\n",
    "'age': [30,66,np.nan,37,28,102,63,35]}\n",
    "# 1.将题目中的 data 以 dataframe 形式进行存储，然后打印该 dataframe\n",
    "data_01=pd.DataFrame(data)\n",
    "# print(data_01)\n",
    "# print(type(data_01))\n",
    "# 2.将 age 列含有空值的位置用 age 列平均值进行填充（在原 dataframe 上进行修改）\n",
    "data_01.age.fillna(value=data_01.age.mean(),inplace=True)\n",
    "# print(data_01)\n",
    "# 3.将含有空值的行删除（在原 dataframe 上进行修改）\n",
    "data_01=data_01.dropna()\n",
    "# print(data_01)\n",
    "# 4.增加一列：salary，salary 值随机生成，范围在 3000----5000 中间\n",
    "data_01['salary']=[np.random.randint(3000,5000) for i in range(data_01.shape[0])]\n",
    "# print(data_01)\n",
    "# 5.以 name 列为横轴，age 为纵轴，绘制柱状图，并且在每一个柱子上方标明 age 值（age 值保留成整数）\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import font_manager\n",
    "my_font=font_manager.FontProperties(fname='C:\\\\Windows\\\\Fonts\\\\simhei.ttf',size=18)\n",
    "plt.figure(figsize=(20,8),dpi=80)\n",
    "x=data_01.name\n",
    "y=data_01.age\n",
    "result=plt.bar(x,y,width=0.5,color=['r','g','b'])\n",
    "#绘制x轴\n",
    "plt.xticks(range(len(data_01.name)),data_01.name,fontproperties=my_font)\n",
    "#设置条形图的文本显示\n",
    "for res in result:\n",
    "    height=res.get_height()\n",
    "    plt.text(res.get_x()+res.get_width()/2,height+0.5,str(int(height)),ha='center',size=15)\n",
    "# plt.show()\n",
    "\n",
    "# 6.将该 dataframe 按照 salary 一列进行降序排列（在原数据上进行修改）\n",
    "data_01.sort_values(by='salary',ascending=False,inplace=True)\n",
    "print(data_01)\n",
    "# 7.将该 dataframe 中性别一列进行修改，将男替换成 1，女替换成 0（在原数据上进行修改）\n",
    "data_01.replace({'男':1,'女':0},inplace=True)\n",
    "print(data_01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "317594a1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f61a723f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
